package com.qhg.saas_server.service.impl;

import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.qhg.saas_server.empty.ReqQueryProduct;
import com.qhg.saas_server.empty.Result;
import com.qhg.saas_server.mapper.ProductManagerMapper;
import com.qhg.saas_server.pojo.Brand;
import com.qhg.saas_server.pojo.Product;
import com.qhg.saas_server.pojo.Producttype;
import com.qhg.saas_server.service.ProductManagerService;
import io.swagger.models.auth.In;
import org.apache.poi.ss.formula.functions.T;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.stream.Collectors;

/**
 *设置模块-商品管理业务实现层
 */
@Service
public class ProductManagerServiceImpl implements ProductManagerService {
    @Autowired
    private ProductManagerMapper productManagerMapper;

    //模糊查询返回分页结果
    @Override
    public PageInfo<Brand> querySomeBrand(String str,Integer currentPage) {
        if(currentPage==null){
            PageHelper.startPage(1,10);
        }else{
            PageHelper.startPage(currentPage,10);
        }
        List<Brand> brandList = productManagerMapper.querySomeBrand(str);
        return new PageInfo<Brand>(brandList);
    }

    //增、改，0增1改
    @Override
    public Result changeBrand(Brand brand,Integer code) {
        //冲突判断
        //如果存在则不再插入(ById)
        //如果存在则修改失败(ByName)
        Integer id = productManagerMapper.getaId("brandId", "brandName", "brand", brand.getBrandName());
        List<String> lists = productManagerMapper.getLists("brandName", "brand", null);
        //增
        if(id == null && code==0 ){//品牌商不存在，插入数据
            productManagerMapper.insertBrand(brand);
            return Result.buildSuccess();
        }
        //改
        else if(code ==1){
            for(String name : lists){
                if(name.equals(brand.getBrandName())){//如果出现冲突
                    if(!name.equals(brand.getOlds())){
                        return Result.error("品牌商已存在，请核实后重新输入或者加上-分店/分部名");
                    }
                }
            }
            productManagerMapper.updateBrand(brand);
            return Result.buildSuccess();
        }
        else{
            return Result.error("品牌商已存在，请核实后重新输入或者加上-分店/分部名");
        }
    }

    //删除品牌信息
    @Override
    public void deleteBrand(Integer id) {
        productManagerMapper.deleteBrand(id);
    }


    //渲染下拉框数据
    @Override
    public List<String> getLists(String columName, String wholeTable,Integer parentId) {
        return productManagerMapper.getLists(columName,wholeTable,parentId);
    }

    //商品管理
    //查询
    @Override
    public PageInfo<Product> queryProduct(ReqQueryProduct reqQueryProduct) {
        if(reqQueryProduct.getCurrentPage()==null){//未传递当前页时默认查询前十条语句
            PageHelper.startPage(1,10);
        }else {
            PageHelper.startPage(reqQueryProduct.getCurrentPage(),10);
        }
        //需要为reqQueryProduct对象设置一个无参product对象，
        // 否则前端未传递product时，77和83行获取到的就是一个空指针，会报空指针异常
        reqQueryProduct.setProduct(new Product());
        //片段控制且只能逐个控制，如果为空不可查询，只能进行全查询和模糊查询
        //品牌选择查询
        if(reqQueryProduct.getBrandName()!=null && reqQueryProduct.getBrandName() != ""){
            //反查brandId
            Integer brandid = productManagerMapper.getaId("brandId", "brandName","brand", reqQueryProduct.getBrandName());
            //设置reqQueryProduct对象内对应id的值
            reqQueryProduct.getProduct().setProduct_brandId(brandid);
        }
        //商品类型选择查询
        if(reqQueryProduct.getProductType()!=null && reqQueryProduct.getProductType() != ""){
            //反查typeId
            Integer typeid = productManagerMapper.getaId("producttypeId", "productType","producttype", reqQueryProduct.getProductType());
            reqQueryProduct.getProduct().setProduct_typeId(typeid);
        }
        //供货商选择
        if(reqQueryProduct.getSupName()!=null && reqQueryProduct.getSupName() != ""){
            //反查supId
            Integer supid = productManagerMapper.getaId("supId", "supName", "supplier", reqQueryProduct.getSupName());
            reqQueryProduct.getProduct().setProduct_supId(supid);
        }
        //商品查询
        List<Product> products = productManagerMapper.queryProduct(reqQueryProduct);
        return new PageInfo<Product>(products);
    }
    //增、改
    //反查id，插入/修改数据，因为三个数据都是必选项，所以不用做非空判断
    @Override
    public Result changeProduct(ReqQueryProduct reqQueryProduct,Integer code) {
        //增、改之前要先判断是否存在
        //插入判存在即可，修改要判断存在个数大于1，因为其本身的名字可以不变
        List<String> lists = productManagerMapper.getLists("productName", "product", null);
        //反查supId,brandId,typeId
        Integer supid = productManagerMapper.getaId("supId", "supName", "supplier", reqQueryProduct.getSupName());
        Integer brandid = productManagerMapper.getaId("brandId", "brandName","brand", reqQueryProduct.getBrandName());
        Integer typeid = productManagerMapper.getaId("producttypeId", "productType","producttype", reqQueryProduct.getProductType());
        //设置id
        reqQueryProduct.getProduct().setProduct_supId(supid);
        reqQueryProduct.getProduct().setProduct_brandId(brandid);
        reqQueryProduct.getProduct().setProduct_typeId(typeid);
        //调用方法，0为插入，1为修改
        if(code==0){
            for(String list : lists){//判存在即可
                if(list.equals(reqQueryProduct.getProduct().getProductName())){
                    return Result.error("产品已存在，请修改数据！");
                }
            }
            productManagerMapper.insertProduct(reqQueryProduct.getProduct());
        }
        if(code==1){
            for(String list : lists){
                //如果名单中有值与要改的值相同
                if(list.equals(reqQueryProduct.getProduct().getProductName())){
                    //比较这个起冲突的值是否是原值，如果不是，则不再修改并返回error
                    if(!list.equals(reqQueryProduct.getOlds())){
                        return Result.error("产品已存在，请修改数据！");
                    }
                }
            }
            productManagerMapper.updateProduct(reqQueryProduct.getProduct());
        }
        return Result.buildSuccess();
    }

    //删
    @Override
    public void deleteProduct(Integer productId) {
        productManagerMapper.deleteProduct(productId);
    }

    //商品类型管理
    //查，要查全部一级和二级，由于后面逻辑设置下，查特定必须分离出来
    @Override
    public PageInfo<Producttype> queryTypes(Integer parentId,Integer currentPage) {
        if(currentPage==null){
            PageHelper.startPage(1,10);
        }else{
            PageHelper.startPage(currentPage,10);
        }
        List<Producttype> producttypeList = productManagerMapper.queryTypes(parentId);
        return new PageInfo<Producttype>(producttypeList);
    }
    //查特定
    @Override
    public PageInfo<Producttype> queryType(Integer parentId,Integer currentPage) {
        if(currentPage==null){
            PageHelper.startPage(1,10);
        }else{
            PageHelper.startPage(currentPage,10);
        }
        List<Producttype> producttypeList = productManagerMapper.queryType(parentId);
        return new PageInfo<Producttype>(producttypeList);
    }
    //增、改；0增1改
    //前端接收的字符串，在业务层反查id实现数据库表的插入
    //再完成控制，如果子类名称冲突，则不再插入
    @Override
    public Result changeType(ReqQueryProduct reqQueryProduct,Integer code) {
        //子类型名冲突判断
        //获取所有子类型 --有缺陷，父子类型名不可相等，否则会插入成功且下一次插入报多结果返回错误
        List<Producttype> producttypeList = productManagerMapper.queryTypes(1);
        //取出所有子类型名并存入一个新的List集合中
        List<String> names = producttypeList.stream()
                .map(Producttype::getProductType)
                .collect(Collectors.toList());
        //反查父类id
        Integer id = productManagerMapper.getaId("productTypeId", "productType",
                "producttype", reqQueryProduct.getProductType());
        //为子类型设置parentId
        //前端作控制，传递过来一定是有数据的，故不必再做非空判断
        reqQueryProduct.getProducttype().setParentId(id);
        //增
        if (code == 0) {
            //循环判断
            for (String name : names) {
                if (name.equals(reqQueryProduct.getProducttype().getProductType())) {
                    return Result.error("数据已存在，请重新输入！");
                }
            }
            //插入数据
            productManagerMapper.insertType(reqQueryProduct.getProducttype());
        }
        //改
        if(code == 1){
            //循环判断
            for (String name : names) {
                if (name.equals(reqQueryProduct.getProducttype().getProductType())) {
                    if(!name.equals(reqQueryProduct.getOlds())){//如果起了冲突且不是原值冲突
                        return Result.error("数据已存在，请重新输入！");
                    }
                }
            }
            //修改数据
            productManagerMapper.updateType(reqQueryProduct.getProducttype());
        }
        return Result.buildSuccess();
    }
    //删
    //通过productTypeId属性，反查id判断要删除的类型是否是父类型
    //删除父类型时，会将所有子类型一并删掉，前端要作确认判断
    //删除子类型时，正常删除
    @Override
    public void deleteType(Integer productTypeId) {
        //查询parentId -测试成功
        Integer parentId = productManagerMapper.getaId("parentId", "productTypeId",
                "producttype", productTypeId.toString());
//        System.out.println("parentId:"+parentId);
        //是父类型
        if(parentId == 0){
            //删除其子类型
            productManagerMapper.deleteType("parentId",productTypeId);
            //删除父类型自身
            productManagerMapper.deleteType("productTypeId",productTypeId);

        }else {//子类型
            productManagerMapper.deleteType("productTypeId",productTypeId);
        }
    }
}
